/*
 * 原版接口
 */
import * as server_ui from "@minecraft/server-ui";
import * as server from "@minecraft/server";
/*
 * 蛋白石数据
 */
import * as data_format from "../data/format";
import * as data_entity from "../data/entity";
import * as data_block from "../data/block";
import * as data_story from "../data/story";
import * as data_item from "../data/item";
/*
 * 蛋白石组件
 */
import * as power_property from "./power_property";
import * as derived_tools from "./derived_tools";
import * as native_tools from "./native_tools";
import * as achieve_plan from "./achieve_plan";
import * as math_tools from "./math_tools";
/*
 * 导出模块
 */
export { Lexicon, Window, GameHelp, Trophy }
/**
 * * 扩展功能
 */
const craft = new Map<string, data_format.INTENTION_NOTE>();
craft.set('调试动态属性',
    {
        root: [],
        priority: 203,
        only: true,
        intel: [],
        code(player): server.RawMessage {
            analysisDynamicProperty(player);
            return ReplyMessages.pursue_dynamic_property;
        }
    }
);
craft.set('调试星尘力',
    {
        root: [],
        priority: 101,
        only: true,
        intel: [],
        code(player): server.RawMessage {
            analysisRealm(player, 'stardust_energy', alterEnergy);
            return ReplyMessages.realm_energy;
        }
    }
);
craft.set('调试虚岩矿脉',
    {
        root: [],
        priority: 102,
        only: true,
        intel: [],
        code(player): server.RawMessage {
            analysisRealm(player, 'mineral_vein', alterMineral);
            return ReplyMessages.realm_mineral;
        }
    }
);
craft.set('重新执行',
    {
        root: ["继续", "重复", "再来"],
        priority: 4,
        only: true,
        intel: [],
        code(player): server.RawMessage {
            /**
             * * 获取 玩家历史输入
             */
            const entry = Lexicon.history.get(player.id);
            if (entry) {
                server.system.runTimeout(() => new Lexicon(player, entry), 10);
                return ReplyMessages.enact_echo
            }
            else return ReplyMessages.unknown_echo;
        }
    }
);
craft.set('调试开发者日志',
    {
        root: [],
        priority: 4,
        only: true,
        intel: [],
        code(): server.RawMessage {
            Lexicon.showLog = !Lexicon.showLog;
            return ReplyMessages.log_toggle;
        }
    }
);
craft.set('发动元素攻击',
    {
        root: [],
        priority: 201,
        only: true,
        intel: [],
        code(player, texts): server.RawMessage {
            analysisRuneHurt(player, texts[0]);
            return ReplyMessages.pursue_rune_hurt;
        }
    }
);
craft.set('设置雾海裂隙',
    {
        root: [],
        priority: 202,
        only: true,
        intel: [],
        code(player, texts): server.RawMessage {
            analysisFissure(player, texts);
            return ReplyMessages.pursue_fissure;
        }
    }
);
craft.set('查询生物群系',
    {
        root: [],
        priority: 8,
        only: true,
        intel: [],
        code(player, texts): server.RawMessage {
            return analysisBiome(player, texts[0]);
        }
    }
);
craft.set('初始化世界规则',
    {
        root: [],
        priority: 2,
        only: true,
        intel: [],
        code(): server.RawMessage {
            server.world.setDynamicProperty('game_rules:regenerate.vacant_space_wasp_tower', true);
            server.world.setDynamicProperty('game_rules:regenerate.starlight_house', true);
            return { text: '#$^$#已重置世界规则, 部分结构可重新生成 !!\n' }
        }
    }
);
/**
 * * 预定义 回复消息
 */
class ReplyMessages {
    /**
     * * 询问需要帮助
     */
    static get ask_for_task(): server.RawMessage {
        return { text: "请问需要我做些什么？" };
    };
    /**
     * * 未知主题
     */
    static get unknown_theme(): server.RawMessage {
        return { text: '#$^$#没太听懂...\n' };
    };
    /**
     * * 未知资料
     */
    static get unknown_paper(): server.RawMessage {
        return { text: '很抱歉... #$^$#好像没有你想要的资料呢...\n' };
    };
    /**
     * * 获得资料
     */
    static get obtain_paper(): server.RawMessage {
        return { text: '#$^$#为您查询到以下资料 : \n\n' };
    };
    /**
     * * 未知群系
     */
    static get unknown_biome(): server.RawMessage {
        return { text: '出错了！ #$^$#没有发现这个群系！\n' };
    };
    /**
     * * 未知节点
     */
    static get unknown_node(): server.RawMessage {
        return { text: '对不起哦, #$^$#没太明白你的意思呢...\n' };
    };
    /**
     * * 未知记忆
     */
    static get unknown_echo(): server.RawMessage {
        return { text: '额... #$^$#不太记得了, 你能详细解释一下吗?\n' };
    };
    /**
     * * 执行记忆
     */
    static get enact_echo(): server.RawMessage {
        return { text: '#$^$#明白 ! 正在执行中 !!\n' };
    };
    /**
     * * 日志开关
     */
    static get log_toggle(): server.RawMessage {
        return { text: '#$^$#收到, 正在切换日志状态\n' };
    };
    /**
     * * 权限不足
     */
    static get power_lack(): server.RawMessage {
        return { text: '咦, 权限不足? #$^$#暂时不能帮你执行这个操作\n' };
    };
    /**
     * * 属性 虚岩矿脉
     */
    static get realm_mineral(): server.RawMessage {
        return { text: '收到, #$^$#将对<§s§l 虚岩矿脉 §r>施加<§q§l 律令 §r>\n' };
    };
    /**
     * * 属性 星尘能量
     */
    static get realm_energy(): server.RawMessage {
        return { text: '明白, #$^$#将对<§u§l 星尘能量 §r>施加<§q§l 律令 §r>\n' };
    };
    /**
     * * 执行 符文伤害
     */
    static get pursue_rune_hurt(): server.RawMessage {
        return { text: '好的, #$^$#正在通过<§q§l 律令 §r>释放<§5§l 符文伤害 §r>\n' };
    };
    /**
     * * 修改 动态属性
     */
    static get pursue_dynamic_property(): server.RawMessage {
        return { text: '好的, #$^$#正在通过<§q§l 律令 §r>修改<§5§l 动态属性 §r>\n' };
    };
    /**
     * * 执行 雾海裂隙
     */
    static get pursue_fissure(): server.RawMessage {
        return { text: '好的, #$^$#正在通过<§q§l 律令 §r>构建<§9§l 雾海裂隙 §r>\n' };
    };
    /**
     * * 无效的构造函数
     */
    protected constructor() { };
};
/**
 * * 『 百科 』模块数据集
 */
class LexiconData {
    /**
     * * 模块的名称标签
     */
    static nameTag: string = '§d§l月华§r';
    /**
     * * 是否显示 运算时 的 参数日志
     */
    static showLog = false;
    /**
     * * 聊天记录缓存 [ 玩家 ID , 文本内容 ]
     */
    static history = new Map<string, string>();
    /**
     * * 进行 数据检索 的 数据库
     */
    static material = [
        ...data_item.help,
        ...data_block.help,
        ...data_story.help,
        ...data_entity.help,
        ...craft
    ];
    /**
     * * 输出文本
     */
    protected output: server.RawMessage = { rawtext: [] };
    /**
     * * 无效的构造函数
     */
    protected constructor() { };
};
/**
 **『 百科 』模块
 */
class Lexicon extends LexiconData {
    /**
     **『 百科 』模块
     * 
     * @param {server.Player} player - 发起对话 的 玩家对象
     * 
     * @param {string} rawtext - 玩家输入的 完整字符串
     */
    constructor(public player: server.Player, rawtext: string) {
        // 继承父类
        super();
        // 检测输入是否为空
        if (!rawtext.length) return;
        /**
         * * 拆分 玩家输入的 完整字符串
         */
        const sections = rawtext.split(/\s+/);
        // 检测输入是否为空
        if (sections.length < 2) sections.push(...rawtext.split(''));
        // 检索数据库
        this.analysisQuery(sections);
        // 保存对话记录
        Lexicon.history.set(player.id, rawtext);
    };
    /**
     * * 检索数据库
     * 
     * @param {string[]} request - 经过 初步处理 的 玩家输入文本组
     */
    protected analysisQuery(request: string[]) {
        /**
         * * 输入字符串
         */
        const entry = request[0];
        /**
         * * 资料内容
         */
        const detail: server.RawMessage[] = [];
        /**
         * * 根标签
         */
        const rootTags = Lexicon.material.map(info => info[1].root);
        /**
         * * 规范化 资料表
         */
        const norm = new Map(Lexicon.material);
        /**
         * * 使用 严谨模式 查询 数据库
         */
        const strictQuery = norm.get(entry);
        /**
         * * 严谨模式下 获得的查询结果
         */
        const strictText = norm.get(entry)?.intel;
        // 严格模式下 如果 获取到 代码 则 执行 代码
        if (strictQuery && strictQuery.code) detail.push(strictQuery?.code(this.player, request.slice(1)));
        // 如果 严谨模式 未能获取到 文本数据 则查询 根标签
        if (strictText) detail.push(...strictText);
        else detail.push(...this.rootTagQuery(false, entry, rootTags, request));
        // 如果 未能查询到数据 则进行 模糊检索
        if (detail.length == 0) detail.push(...this.rootTagQuery(true, entry, rootTags, request));
        // 如果 未能查询到数据 则返回 默认文本
        if (detail.length == 0) detail.push(ReplyMessages.unknown_paper);
        // 输出文本
        if (detail.length >= 5) this.output.rawtext?.push(ReplyMessages.obtain_paper, ...detail);
        else this.output.rawtext?.push(...detail);
    };
    /**
     * * 基于 根标签 进行 检索 资料库
     * 
     * @param {boolean} type - 是否启用模糊搜索
     * 
     * @param {string} input - 输入的 搜索内容
     * 
     * @param {string[][]} tags - 搜索的 标签数组
     * 
     * @param {string[]} rawtexts - 原始文本数组
     * 
     * @returns {server.RawMessage[]} - 搜索结果
     */
    protected rootTagQuery(type: boolean, input: string, tags: string[][], rawtexts: string[]): server.RawMessage[] {
        /**
         * * 数据库
         */
        const sample: data_format.INTENTION_NOTE[] = Lexicon.material.map(info => info[1]);
        /**
         * * 唯一性检测
         */
        const detect: [data_format.INTENTION_NOTE, number][] = [];
        /**
         * * 信息输出
         */
        const output: server.RawMessage[] = [];
        // 检索资料
        tags.forEach(
            (tag, index) => {
                /**
                 * * 当前 被选中 的 信息对象
                 */
                const target = sample[index];
                /**
                 * * 构建资料名称
                 */
                const title = { text: '§q§l' + target.root.join(' - ') + '§r\n\n' };
                /**
                 * * 文本结尾
                 */
                const finale = { text: '\n=-=-=-=-=-=-=-=-=-=\n' };
                /**
                 * * 当前信息对象 的 模糊检测 阈值
                 */
                const confine = target.confine ?? 0.25;
                /**
                 * * 计算 文本关联度
                 */
                const proximity = Lexicon.Correlation(input, target.root.join('*'), tag);
                // 提取合适的数据
                switch (type) {
                    // 当前信息对象 进行 模糊检测
                    case true: if (proximity >= confine)
                        target.only
                            ? detect.push([target, proximity])
                            : output.push(title, ...target.intel, finale);
                        break;

                    // 当前信息对象 进行 标签检测
                    default: if (new Set(tag).has(input))
                        target.only
                            ? detect.push([target, proximity])
                            : output.push(title, ...target.intel, finale);
                        break;
                }
            }
        );
        // 如果 唯一性检测 为空 则返回 所有资料页
        if (detect.length == 0) return output;
        // 如果 唯一性检测 不为空 则返回 最高优先级资料页
        else {
            /**
             * * 获取 优先级数组
             */
            const detectMap = detect.map(info => info[0].priority ?? 0 * info[1]);
            /**
             * * 获取 最高优先级
             */
            const maxPriority = Math.max(...detectMap);
            /**
             * * 获取 节点索引
             */
            const index = detectMap.indexOf(maxPriority);
            /**
             * * 获取 随机输出
             */
            const randomOutput = detect[math_tools.Random({ min: 0, max: detect.length - 1 }, true)][0].intel;
            // 如果 最高优先级为 0 则返回 随机输出
            if (maxPriority == 0) return randomOutput;
            // 如果 最高优先级不为 0 则返回 最高优先级资料页 并 执行模块函数
            else {
                /**
                 * * 获取 函数运行后的 反馈
                 */
                const feedback = detect[index][0].code?.(this.player, rawtexts.slice(1));
                /**
                 * * 复制 文献数据
                 */
                const intelCopy = [...detect[index][0].intel];
                // 添加 反馈信息
                if (feedback) intelCopy.push(feedback);
                // 输出 文献 与 反馈信息
                return intelCopy;
            }
        }
    };
    /**
     * * 获取 实例输出信息
     */
    public get interface(): server.RawMessage { return Lexicon.Format(this.output) };
    /**
     * * 修饰 输出信息
     * 
     * @param {server.RawMessage} input - 等待修饰的原始文本
     * 
     * @returns {server.RawMessage} - 修饰后的文本信息
     */
    static Format(input?: server.RawMessage): server.RawMessage {
        /**
         * * 模型规模
         */
        const model = Lexicon.material.length;
        /**
         * * 样本规模
         */
        const paper = Lexicon.material.map(info => info[1].intel.length).reduce((pre, next) => pre + next);
        /**
         * * 文本总长度
         */
        const total = Lexicon.material.flatMap(info => info[1].intel).map(info => info?.text?.length ?? 0).reduce((pre, next) => pre + next);
        /**
         * * 默认文本
         */
        const template: server.RawMessage = {
            rawtext: [
                { text: `嗨, 我是${Lexicon.nameTag}, 很高兴遇见你 !\n` },
                { text: '--------------------------------\n' },
                { text: '让我来介绍一个超级棒的[§s 最终档案馆 §r]项目 !\n' },
                { text: '那就是<§d Intention.v2 [ 意图 ] §r>模块 ! 听起来是不是很厉害 ?\n' },
                { text: '它是用§p MinecraftBE §r的§q ServerAPI §r精心打造的哦 !\n' },
                { text: `模块里藏着§s ${model} §r个精巧的组件, 每个都有它的小秘密 !\n` },
                { text: `样本库有§q ${paper} §r个精彩样本, 每一个都独一无二 !\n` },
                { text: `文献规模达到了§u ${total} §r个字, 每一个字都是我们智慧的结晶 !\n` },
                { text: '这些数据会帮助我更快地找到你需要的信息, 就像魔法一样哦 !\n' },
                { text: '--------------------------------\n' },
            ]
        };
        // 替换名称
        input?.rawtext?.forEach(
            info => {
                if (info && info.text) {
                    info.text = info.text.replace(/(#\$[\^]+\$\#)/g, Lexicon.nameTag);
                }
            }
        );
        // 返回文本
        if (input && input?.rawtext?.length) return input
        else return template
    };
    /**
     * * 发送至 聊天栏
     * 
     * @param {server.Player} player - 发送聊天信息的玩家
     * 
     * @param {server.RawMessage}input - 等待修饰的原始文本
     */
    static SendToChat(player: server.Player, input: server.RawMessage) {
        // 替换名称
        input.rawtext?.forEach(
            info => {
                if (info && info.text) {
                    info.text = info.text.replace(/(#\$[\^]+\$\#)/g, Lexicon.nameTag);
                }
            }
        );
        // 将文本输出到聊天框
        player.sendMessage(input);
    }
    /**
     * 基于 关键词 获得 匹配度积分
     * 
     * @param {string} input - 玩家输入的关键词
     * 
     * @param {string} type - 节点类型
     * 
     * @param {string[]} source - 样本数组
     * 
     * @returns {number} - 匹配度, 四舍五入到小数点后三位
     */
    static Correlation(input: string, type: string, source: string[]): number {
        /**
         * * 初始化关键词
         */
        const sample = new Set(source.join('').split(''));
        /**
         * * 拆分输入信息
         */
        const stage = [...new Set(input.split(''))];
        /**
         * * 相同字符数
         */
        let score = 0;
        // 统计 输入字符串 与 关键词 的匹配程度
        stage.forEach(node => sample.has(node) ? score++ : 0);
        /**
         * * 计算得分
         */
        const count = Math.floor((score / sample.size) * 1000) / 1000;
        /**
         * * 日志参数 - 样本规模
         */
        const sampleData = '§r | §5' + '总规模:§2 ' + sample.size;
        /**
         * * 日志参数 - 匹配度
         */
        const countData = '§r | §5' + '匹配度:§2 ' + count;
        /**
         * * 日志参数 - 相同字数
         */
        const scoreData = '§r | §5' + '相同字:§2 ' + score;
        // 输出日志
        if (Lexicon.showLog && count != 0) console.error('§p' + type + countData + scoreData + sampleData);
        // 输出结果
        return count;
    };
};
/**
 * * 解析 动态属性
 * 
 * @param {server.Player} player - 发起对话 的 玩家对象
 */
function analysisDynamicProperty(player: server.Player) {
    // 检测玩家是否具有权限
    if (!native_tools.PlayerInPower(player)) return Lexicon.SendToChat(player, ReplyMessages.power_lack);
    /** 
     * * 设定查询参数
     */
    const options: server.EntityQueryOptions = {
        excludeTypes: ["minecraft:item", "minecraft:xp_orb"]
    };
    /**
     * * 获取 实体 的 距离信息
     */
    const Distance = (entity: server.Entity) => Math.floor(math_tools.Vector.distance(player.location, entity.location));
    /**
     * * 获取 实体数组
     */
    const queue = native_tools.EntitysSort(player.dimension, options, (a, b) => Distance(a) - Distance(b), entity => entity.getComponent('minecraft:health'));
    /** 
     * * 定义了 窗口界面 的 标题 
     */
    const title: server.RawMessage = {
        text: "§9§l<§u 动态属性 §9>§r§3操作界面"
    };
    /** 
     * * 定义了 窗口界面 的 表单对象
     */
    const display = new server_ui.ActionFormData().title(title);
    /** 
     * * 获取 实体 的 名称信息
     */
    const Intel = (entity: server.Entity): server.RawMessage => {
        return {
            rawtext: [
                { text: '§l' },
                native_tools.EntityTranslate(entity),
                { text: `\n§r§l§9距离: §5${Distance(entity)}` }
            ]
        }
    };
    // 遍历 实体数组 并 加入 按钮
    queue.forEach(entity => display.button(Intel(entity), "textures/项目图标/元素增益"));
    // 显示 窗口界面
    display.show(player).then(
        option => {
            if (option.selection == undefined || queue.length === 0) return;
            /**
             * * 获取 目标 实体
             */
            const target = queue[option.selection];
            /**
             * * 创建 动态属性 缓存对象
             */
            const property = new Map<string, string | number | boolean | server.Vector3>();
            /**
             * * 获取 实体 的 动态属性类型数组
             */
            const types = target.getDynamicPropertyIds();
            /**
             * * 获取 实体 的 动态属性值数组
             */
            const values = types.map(type => target.getDynamicProperty(type));
            // 遍历 类型数组 并 加入 键值对
            types.forEach((type, index) => { const args = values[index]; if (args) property.set(type, args) });
            /**
             * * 序列化 动态属性 并排序
             */
            const analysis = [...property].sort(
                (a, b) => {
                    // 比较两个字符串的首字母, 不区分大小写
                    return a[0].toLowerCase().charCodeAt(0) - b[0].toLowerCase().charCodeAt(0);
                }
            );
            /**
             * * 表单对象
             */
            const display = new server_ui.ModalFormData().title(title);
            /**
             * * 输入框提示
             */
            const text: server.RawMessage = { text: "请勿随意修改, 以免发生故障" };
            // 输入动态属性信息
            analysis.forEach(type => display.textField(type[0], text, JSON.stringify(type[1])));
            // 显示表单
            display.show(player).then(
                option => {
                    if (!option.formValues) return;
                    option.formValues.forEach(
                        (data, index) => {
                            target.setDynamicProperty(analysis[index][0], JSON.parse(data as string))
                        }
                    )
                }
            );
        }
    );
};
/**
 * * 解析 领域属性
 * 
 * @param {server.Player} player - 发起对话 的 玩家对象
 * 
 * @param {string} text - 进行查询的 领域属性的 类型
 * 
 * @param {(option: server_ui.ActionFormResponse) => void} after - 窗口关闭后的回调函数
 */
function analysisRealm(player: server.Player, text: string, after: (player: server.Player, args: INTENTION_REALM_AFTER) => void) {
    /**
     * * 领域属性 标识符
     */
    const entry = server.world.getDynamicPropertyIds().filter(node => node.startsWith(`${text}•`)).sort((a, b) => a.length - b.length);
    /**
     * * 领域属性 状态值
     */
    const state = entry.map(node => server.world.getDynamicProperty(node));
    /** 
     * * 定义了 窗口界面 的 标题 
     */
    const title: server.RawMessage = {
        text: "§9<§l " + text + " §r§9>"
    };
    /** 
     * * 定义了 窗口界面 的 表单对象
     */
    const display = new server_ui.ActionFormData().title(title);
    /**
     * * 将 领域属性坐标 映射为 世界坐标字符串
     * 
     * @param node - 领域属性名称
     * 
     * @returns {string} - 领域属性的 坐标字符串
     */
    const mapping = (node: string): string => {
        const analysis = node.split(/•/).map(node => Number(node));
        const anchor: server.Vector3 = { x: analysis[2] * 16, y: 0, z: analysis[4] * 16 };
        return math_tools.Vector.toString(anchor);
    };
    if (entry.length >= 1) entry.forEach((info, index) => display.button('§l§9基准坐标 : §5' + mapping(info) + '\n§9属性值 : §r§u' + state[index]));
    else display.button('§4§l未创建§r : §u领域属性§9 -> §r' + text);
    // 显示窗口界面
    display.show(player).then(
        option => {
            //检测玩家是否退出窗口
            if (option.canceled || option.selection == undefined) return;
            if (entry.length == 0) return;
            after(player, { option, entry, state });
        }
    )
};
/**
 * * 修改 星尘能量
 * 
 * @param {server.Player} player - 发起对话 的 玩家对象
 * 
 * @param {INTENTION_REALM_AFTER} args - 表单返回 的 参数
 */
function alterEnergy(player: server.Player, args: INTENTION_REALM_AFTER) {
    /**
     * * 标题
     */
    const title: server.RawMessage = { text: "§9《§u§l 调试 - 星尘能量 §9》§r" };
    /**
     * * 输入框提示
     */
    const text: server.RawMessage = { text: "请勿随意修改, 以免发生故障" };
    /**
     * * 预输入文本
     */
    const plan: server.RawMessage = { text: `${args.state[args.option.selection ?? 0]}` };
    /**
     * * 输入框提示
     */
    const prompt: server.RawMessage = { text: '§c数据类型§r:§u 能量值' };
    /**
     * * 表单对象
     */
    const display = new server_ui.ModalFormData().title(title).textField(prompt, text, plan.text);
    // 显示表单
    display.show(player).then(
        option => {
            if (!option.formValues) return;
            if (native_tools.PlayerInPower(player)) {
                /**
                 * * 状态属性值
                 */
                const property = Number((option.formValues as string[])[0]) ?? 0;
                // 更新 领域属性
                server.world.setDynamicProperty(args.entry[args.option.selection ?? 0], property)
            }
            // 发送权限不足的消息
            else Lexicon.SendToChat(player, ReplyMessages.power_lack);
        }
    )
};
/**
 * * 修改 虚岩矿脉
 * 
 * @param {server.Player} player - 发起对话 的 玩家对象
 * 
 * @param {INTENTION_REALM_AFTER} args - 表单返回 的 参数
 */
function alterMineral(player: server.Player, args: INTENTION_REALM_AFTER) {
    /**
     * * 标题
     */
    const title: server.RawMessage = { text: "§9《§u§l 调试 - 虚岩矿脉 §9》§r" };
    /**
     * * 输入框提示
     */
    const text: server.RawMessage = { text: "请勿随意修改, 以免发生故障" };
    /**
     * * 解析 领域属性
     */
    const analysis = JSON.parse(`${args.state[args.option.selection ?? 0]}`) as { type: string[], amount: number[] };;
    /**
     * * 原始 矿石数量
     */
    const proto_amount = analysis.amount;
    /**
     * * 原始 矿石类型
     */
    const proto_type = analysis.type;
    /**
     * * 表单对象
     */
    const display = new server_ui.ModalFormData().title(title);
    // 添加 矿物类型输入框
    proto_type.forEach(type => display.textField('§c数据类型§r:§u 矿物类型', text, type));
    // 添加 矿物数量输入框
    display.textField('§c数据类型§r:§u 矿物数量', text, proto_amount.toString());
    // 显示表单
    display.show(player).then(
        option => {
            if (!option.formValues) return;
            if (native_tools.PlayerInPower(player)) {
                /**
                 * * 矿脉 的 矿石类型
                 */
                const type: string[] = option.formValues.slice(0, proto_type.length) as string[];
                /**
                 * * 矿脉 的 矿石数量
                 */
                const amount = (option.formValues[proto_type.length] as string).split(',').map(Number);
                // 设置 领域属性
                server.world.setDynamicProperty(args.entry[args.option.selection ?? 0], JSON.stringify({ type, amount })); // 使用模板字符串拼接类型和数量
            }
            // 发送权限不足的消息
            else Lexicon.SendToChat(player, ReplyMessages.power_lack);
        }
    )
};
/**
 * * 解析 符文伤害
 * 
 * @param {server.Player} player - 发起对话 的 玩家对象
 * 
 * @param {string} text - 输入字符串
 */
function analysisRuneHurt(player: server.Player, text: string) {
    // 检测玩家是否具有权限
    if (!native_tools.PlayerInPower(player)) return Lexicon.SendToChat(player, ReplyMessages.power_lack);
    /**
     * * 获取 伤害值
     */
    const damage = (text.match(/\b\d+(\.\d+)?\b/g)?.map(Number) ?? [1])[0];
    /**
     * * 获取 实体属性
     */
    const property = power_property.MergeProperty(power_property.GetProperty(player), { raise_basic_attack: damage });
    /**
     * * 是否暴击
     */
    const erupt = derived_tools.IsErupt(player);
    /** 
     * * 设定查询参数
     */
    const options: server.EntityQueryOptions = {
        excludeTypes: ["minecraft:item", "minecraft:xp_orb", player.typeId],
        excludeFamilies: ['starry']
    };
    /**
     * * 获取 实体 的 距离信息
     */
    const Distance = (entity: server.Entity) => Math.floor(math_tools.Vector.distance(player.location, entity.location));
    /**
     * * 获取 排序后 的 实体队列
     */
    const queue = native_tools.EntitysSort(player.dimension, options, (a, b) => Distance(a) - Distance(b), entity => !entity.getComponent('minecraft:is_tamed'));
    /** 
     * * 定义了 窗口界面 的 标题 
     */
    const title: server.RawMessage = {
        text: "§9<§u§l 符文伤害 §9>§r§9操作界面"
    };
    /** 
     * * 定义了 窗口界面 的 表单对象
     */
    const display = new server_ui.ActionFormData().title(title);
    /** 
     * * 获取 实体 的 名称信息
     */
    const Intel = (entity: server.Entity): server.RawMessage => {
        return {
            rawtext: [
                { text: '§l' },
                native_tools.EntityTranslate(entity),
                { text: `\n§9距离: §5${Distance(entity)}` }
            ]
        }
    };
    // 遍历 实体队列 并 加入 按钮
    if (queue.length >= 1) queue.forEach(entity => display.button(Intel(entity)));
    else display.button('§4§l不存在 §c<§9 可以§6<§u 选中 §6>§9的实体 §c>§r');
    // 显示 窗口界面
    display.show(player).then(
        option => {
            if (option.selection == undefined) return;
            if (queue.length == 0) return;
            /**
             * * 获取 目标对象
             */
            const target = queue[option.selection];
            achieve_plan.RunePowerAttack.BriefCreate(player, target, erupt, property);
        }
    );
};
/**
 * * 解析 雾海裂隙
 * 
 * @param {server.Player} player - 发起对话 的 玩家对象
 * 
 * @param {string} texts - 输入字符串
 */
function analysisFissure(player: server.Player, texts: string[]) {
    // 检测玩家是否具有权限
    if (!native_tools.PlayerInPower(player)) return Lexicon.SendToChat(player, ReplyMessages.power_lack);
    /**
     * * 解析参数 - 坐标
     * 
     * @returns {server.Vector3} - 返回坐标
     */
    const location = (): server.Vector3 => {
        /**
         * * 匹配整数和小数, 包括负数
         */
        const matches = texts.join().match(/-?\b\d+(\.\d+)?\b/g);
        /**
         * * 原始向量数组
         */
        const proto = matches?.map(Number) ?? [0, 512, 0];
        return { x: proto[0] ?? 0, y: proto[1] ?? 512, z: proto[2] ?? 0 };
    };
    /**
     * * 解析参数 - 维度
     * 
     * @returns {server.Dimension} - 返回维度
     */
    const dimension = (): server.Dimension => {
        /**
         * * 检测 字符串
         */
        const check = texts[3] ?? '主世界';
        // 输出维度
        return server.world.getDimension(data_story.dimension_map.get(check) ?? 'minecraft:overworld');
    };
    /**
     * * 坐标组
     */
    const location_group = [player.getHeadLocation(), location()];
    /**
     * * 维度组
     */
    const dimension_group = [player.dimension, dimension()];
    /**
     * * 源坐标
     */
    const source = { location: player.getHeadLocation(), dimension: player.dimension };
    // 播放 声音
    server.system.runTimeout(() => player.playSound("ambient.weather.thunder"), 100);
    server.system.runTimeout(() => player.playSound("ambient.weather.thunder"), 10);
    // 显示数字
    server.system.runTimeout(() => derived_tools.NumberParticleDisplay(source, 4, math_tools.Vector.CONSTANT_ZERO), 15);
    server.system.runTimeout(() => derived_tools.NumberParticleDisplay(source, 3, math_tools.Vector.CONSTANT_ZERO), 35);
    server.system.runTimeout(() => derived_tools.NumberParticleDisplay(source, 2, math_tools.Vector.CONSTANT_ZERO), 55);
    server.system.runTimeout(() => derived_tools.NumberParticleDisplay(source, 1, math_tools.Vector.CONSTANT_ZERO), 75);
    server.system.runTimeout(() => derived_tools.NumberParticleDisplay(source, 0, math_tools.Vector.CONSTANT_ZERO), 95);
    // 创建 雾海裂隙
    server.system.runTimeout(() => achieve_plan.MistySeaFissure.Create(player.id, 30, { location_group, dimension_group }), 80);
};
/**
 * * 解析 生态群系
 * 
 * @param {server.Player} player - 发起对话 的 玩家对象
 * 
 * @param {string} text - 输入字符串
 */
function analysisBiome(player: server.Player, text: string): server.RawMessage {
    /**
     * * 查询 生态群系 的 维度
     */
    const dimension = player.dimension;
    /**
     * * 生态群系 的 标识符映射
     */
    const biome = data_story.biome_map.get(text);
    // 如果 不存在标识符 就 返回未找到
    if (!biome) return ReplyMessages.unknown_biome;
    /**
     * * 查询 生态群系 的 坐标
     */
    const biomeLocation = dimension.findClosestBiome(player.location, biome);
    // 如果 找到生态群系 就 显示 并 添加锚点
    if (biomeLocation) {
        /**
         * * 反馈文本
         */
        const feedback: server.RawMessage[] = [
            { text: `${Lexicon.nameTag}找到你说的群系了哦 ！\n\n` },
            { text: `§n生态群系§r :§u§l ${biome}§r\n\n` },
            { text: `§q群系坐标§r :§s§l ${math_tools.Vector.toString(biomeLocation)}§r\n\n` },
            { text: `${Lexicon.nameTag}已经帮你添加好<§9§l 传送锚点 §r>了哦 ！\n` },
        ];
        /**
         * * 传送锚点
         */
        const anchor = JSON.stringify({ location: math_tools.Vector.floor(biomeLocation), dimension: dimension.id });
        player.setDynamicProperty('road_sign:' + text, anchor);
        return { rawtext: feedback }
    }
    else return ReplyMessages.unknown_biome;
};
/**
 * * 使用 窗口界面 进行交互
 * 
 * @param {server.Player} player - 发起对话 的 玩家对象
 * 
 * @param {server.RawMessage} content - 在界面上显示的文本
 */
function Window(player: server.Player, content?: server.RawMessage) {
    /**
     * * 标题
     */
    const title: server.RawMessage = { text: "§9《§u§l §r" + LexiconData.nameTag + "§u§l百科 §9》§r" };
    /**
     * * 获取 玩家背包
     */
    const container = player.getComponent('minecraft:inventory')?.container;
    /**
     * * 获取 选中的物品的ID
     */
    const typeID = container?.getItem(player.selectedSlotIndex)?.typeId;
    /**
     * * 默认文本
     */
    const defaultText = !content ? typeID : undefined;
    /**
     * * 表单对象
     */
    const display = new server_ui.ModalFormData().title(title).textField(Lexicon.Format(content), ReplyMessages.ask_for_task, defaultText);
    // 检测是否输入了文本
    if (content?.rawtext) {
        // 根据 输入的文本长度 进行判断 是否显示在聊天栏中
        if (JSON.stringify(content).length < 72) player.sendMessage(content);
        // 如果不是 则显示表单
        else display.show(player).then(
            option => {
                if (option.canceled || !option.formValues) return;
                Window(player, new Lexicon(player, option.formValues[0] as string).interface);
            }
        )
    }
    // 如果不是 则显示默认表单
    else display.show(player).then(
        option => {
            // 如果 玩家取消了表单 则 返回
            if (option.canceled || !option.formValues) return;
            Window(player, new Lexicon(player, option.formValues[0] as string).interface);
        }
    )
};
/**
 * * 设置 辅助说明 的 标题
 * 
 * @param {server.ItemStack | server.Block | server.Entity} source - 进行查询的源对象
 * 
 * @param {server.RawMessage} title - 进行设置 的 原始消息 标题对象
 */
function GameHelpTitle(source: server.ItemStack | server.Block | server.Entity, title: server.RawMessage) {
    // 根据源的类型, 添加相应的前缀和后缀到标题中
    if (source instanceof server.Entity) {
        title.rawtext?.push({ text: '§9<§l ' }, native_tools.EntityTranslate(source), { text: ' §r§9>§r' });
    }
    else if (source instanceof server.Block) {
        title.rawtext?.push({ text: '§9<§l ' }, native_tools.BlockTranslate(source), { text: ' §r§9>§r' });
    }
    else if (source instanceof server.ItemStack) {
        title.rawtext?.push({ text: '§9<§l ' }, native_tools.ItemTranslate(source), { text: ' §r§9>§r' });
    }
};
/**
 * * 显示一个表单 包括标题、帮助信息以及两个按钮（关闭和导出）
 * 
 * @param {server.Player} player 玩家对象, 即这个用户界面的显示对象
 * 
 * @param {server.RawMessage} title 标题内容, 一个包含原始消息的对象
 * 
 * @param {server.RawMessage} text 帮助信息, 一个包含原始消息的对象
 */
function GameHelpShow(player: server.Player, title: server.RawMessage, text: server.RawMessage) {
    // 创建并显示带有标题、帮助信息、关闭和导出按钮的用户界面
    new server_ui.ActionFormData()
        .title(title)
        .body(text)
        .button('§4§l关闭§r')
        .button('§9§l导出§r')
        .show(player)
        .then(
            result => {
                // 处理用户界面关闭或导出操作后的逻辑
                if (result.canceled || result.selection == 0) return;
                player.sendMessage(
                    {
                        rawtext: [
                            { text: '\n=-=-=-=-=-=-=-=-=-=\n' },
                            title,
                            { text: '\n\n' },
                            text
                        ]
                    }
                )
            }
        )
};
/**
 * * 查询 目标 辅助说明
 * 
 * @param {server.Player} player - 查询帮助文本的玩家
 * 
 * @param {server.ItemStack | server.Block | server.Entity} source - 进行查询的源对象
 */
function GameHelp(player: server.Player, source: server.ItemStack | server.Block | server.Entity) {
    /**
     * * 初始化 标题对象
     */
    const title: server.RawMessage = { rawtext: [] };
    /**
     * * 初始化 文本对象
     */
    const text: server.RawMessage = { rawtext: [] };
    /**
     * * 获取 辅助说明
     */
    const query = new Lexicon(player, source.typeId).interface;
    // 根据源类型设置标题
    GameHelpTitle(source, title);
    // 添加查询内容到帮助界面
    text.rawtext?.push(query);
    // 显示界面
    GameHelpShow(player, title, text);
};
/**
 * * 解析任务进度
 * 
 * @param {server.Player} player - 玩家对象
 * 
 * @param {server_ui.ActionFormResponse} option - 表单返回
 * 
 * @param {[string, data_format.SCHEDULE_NOTE][]} entry - 任务进度列表
 */
function analysisTrophy(player: server.Player, option: server_ui.ActionFormResponse, entry: [string, data_format.SCHEDULE_NOTE][]) {
    // 检测玩家是否未做出选择
    if (option.selection == undefined) return;
    /**
     * * 获取 玩家背包
     */
    const container = player.getComponent('inventory')?.container;
    /**
     * * 玩家选中的计划
     */
    const select = entry[option.selection][1];
    // 判断背包是否存在
    if (!container) return;
    // 判断是否满足前处理函数的条件
    if (select.before && !select.before(player))
        return player.onScreenDisplay.setTitle(
            [
                { text: `§4§l条件不满足\n无法完成任务\n§6< §u` },
                { text: entry[option.selection][0] },
                { text: '§6 >§r' }
            ]
        );
    // 判断是否满足删除特定物品的条件
    if (select.attrition && !native_tools.CheckItemStack(container, select.attrition))
        return player.onScreenDisplay.setTitle(
            [
                { text: `§4§l物品数量不足\n无法完成任务\n§p< §u` },
                { text: entry[option.selection][0] },
                { text: '§6 >§r' }
            ]
        );
    // 删除特定物品
    select.attrition?.forEach(item => native_tools.DeleteItemStack(container, item));
    // 给与任务完成奖励
    if (select.reward) select.reward.forEach(item => container.addItem(item));
    // 添加 任务标签
    if (select.onDone) select.onDone.forEach(info => player.addTag(info));
    // 播放 引导提示
    if (select.prompt) derived_tools.PlayPrompt(player, select.prompt);
    // 执行后处理函数
    if (select.after) select.after(player);
    // 任务完成后的特效提示
    player.onScreenDisplay.setTitle(
        [
            { text: `§6§l恭喜你完成任务\n§d< §9` },
            { text: entry[option.selection][0] },
            { text: '§d >§r' }
        ]
    );
    player.spawnParticle('constant:fireworks_fireball_rune_orange', player.getHeadLocation());
    player.spawnParticle('constant:fireworks_paper_rune_orange', player.getHeadLocation());
    player.playSound('firework.twinkle');
};
/**
 * * 构建 奖励与任务 界面
 * 
 * @param {server.Player} player - 尝试进行交互的玩家对象
 * 
 * @param {server.RawMessage} title - 任务界面的标题
 * 
 * @param {Map<string, data_format.SCHEDULE_NOTE>} data - 任务数据
 */
function Trophy(player: server.Player, title: server.RawMessage, data: Map<string, data_format.SCHEDULE_NOTE>) {
    // 检测玩家是否正在执行其他任务
    if (!achieve_plan.ControlEventTrigger.EntityToken('Trophy', player, 200)) return player.onScreenDisplay.setTitle('§l§c请稍后再试!');
    /** 
     * * 定义了 窗口界面 的 表单对象
     */
    const display = new server_ui.ActionFormData().title(title);
    /**
     * * 获取 玩家拥有的标签
     */
    const tags = new Set(player.getTags());
    /**
     * * 获取 玩家拥有的计划
     */
    const entry = [...data].filter(info => info[1]?.rely?.every(tag => tags.has(tag)) ?? true)
        .filter(info => !info[1]?.onDone?.every(tag => tags.has(tag)) ?? false);
    // 检测是否有满足条件的计划
    if (entry.length == 0) return player.onScreenDisplay.setTitle({ text: '§l§m没有了哦, 什么都没有了啦...' });
    // 添加 计划按钮
    entry.forEach(info => display.button({ rawtext: info[1].refer }, info[1].texture));
    // 显示 窗口界面
    display.show(player).then(option => analysisTrophy(player, option, entry));
};
/**
 * * 「意图」 - 领域属性 - 后处理函数
 */
interface INTENTION_REALM_AFTER {
    /**
     * * 领域属性 状态值
     */
    state: (string | number | boolean | server.Vector3 | undefined)[];
    /**
     * * 界面选项
     */
    option: server_ui.ActionFormResponse;
    /**
     * * 领域属性 识别名称
     */
    entry: string[];
};